The Arsenal Files 1

home *** CD-ROM | disk | FTP | other *** search

/ The Arsenal Files 1 / The Arsenal Files (Arsenal Computer).ISO / os2_app / cs0056-1.dsk / CSDFIXES.LST next >

Wrap

File List | 1994-01-31 | 52.4 KB | 664 lines

╒════════════════════════════════════════════════════════════════════════════╕ │ │ │ C Set/2 Release 1.0 Fixes │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ APAR Number │ Problem Description │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ03523 │ Optimization Problem: Bad register selection causes │ │ │ general protection fault at runtime. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ03662 │ Optimization Problem: Bad register selection around a │ │ │ call causes incorrect output at runtime. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ03682 │ Optimization Problem: Tail call optimization was altering │ │ │ a register erroneously. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ03767 │ The compiler could not open files with names containing │ │ │ DBCS characters where the second byte of the characters │ │ │ was 0x5C. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ03923 │ Optimization Problem: Generated floating-point code was │ │ │ causing the floating-point register stack to overflow or │ │ │ underflow. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ03948 │ Optimization Problem: Multiplying by constant negative │ │ │ numbers which are powers of 2 was causing incorrect code │ │ │ to be generated. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ03952 │ Optimization Problem: Multiplying by constants that are │ │ │ near powers of 2 was causing incorrect code to be │ │ │ generated. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ03957 │ Compiler was emitting object records longer than the │ │ │ linker's 1024 byte limit. This causes the linker to │ │ │ produce the message "L1057: data record too large. │ │ │ │ │ │ NOTE: There is more than one cause for this symptom │ │ │ and fix coming soon. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Compile time performance was improved. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ The compiler was unable to find files in a subdirectory │ │ │ on a LAN drive. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00008 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ04295 │ The kbhit library function was not working. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00009 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ04465 │ The cprintf, fprintf, printf, and sprintf functions were │ │ │ not printing floating-point values between 0.5 and 1.0 │ │ │ correctly when zero precision was specified. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00010 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ04602 │ Optimization Problem: Simple loops with induction variable│ │ │ increments greater than one were being incorrectly turned │ │ │ into memset or memcpy builtin function calls. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ04604 │ When the compiler turned switch statements into jump │ │ │ tables, default code segment was always being referenced │ │ │ even the if the function containing the switch statement │ │ │ was specified in an alloc_text pragma. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ04652 │ Optimization Problem: The stack pointer was not being │ │ │ decremented before an indirect _Optlink call where the │ │ │ return value was being used as a parameter to a tail call.│ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ04674 │ When #pragma handler was specified for a 32-bit callback │ │ │ function the compiler generated bad code for copying the │ │ │ parameters from the 16-bit stack to the 32-bit stack. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00011 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ04811 │ Incorrect code was being generated for a complicated │ │ │ expression where a short variable was being added to the │ │ │ address of an element of an array of structures. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05088 │ Optimization Problem: The compiler was trapping when │ │ │ optimizing a loop containing a divide and modulo operation│ │ │ with the same operands. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05100 │ Optimization Problem: Incorrect code was being generated │ │ │ for a switch statement containing a case zero where the │ │ │ switch variable had to be converted to an int from an │ │ │ unsigned char. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05124 │ Incorrect code was being generated when the result of │ │ │ comparing two shorts with less than or greater than │ │ │ operators was stored into an integer variable. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05140 │ Incorrect code was being generated for _Optlink functions │ │ │ that have a number of floating-point or aggregate │ │ │ parameters followed by integer parameters. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00012 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ05013 │ The compiler was trapping when trying to compile a │ │ │ complicated expression where the address of an element of │ │ │ an array of structures was indexed and then a member of │ │ │ the structure was accessed. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ04674 │ The problem with #pragma handler on callback functions was│ │ │ really only a problem with _Far16 _Cdecl callback │ │ │ functions. So the fix in CSD0011 broke the case where │ │ │ #pragma handler was used on a _Far16 _Pascal callback │ │ │ function. Now both work. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ04390 │ The C runtime termination routine was not freeing all │ │ │ storage allocated during initialization. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05087 │ Partial static initialization of a structure containing │ │ │ a union containing a structure containing bitfields was │ │ │ not working. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Some enhancements were made to the compiler to reduce │ │ │ memory usage dring compilation and therefore reduce │ │ │ compile times. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00013 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ05087 │ The assembler listing was incorrect after the real problem│ │ │ was fixed in CSD0013. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05225 │ Optimization Problem: The compiler was trapping when │ │ │ optimizing a procedure containing a loop nested within │ │ │ another loop where an invariant in the inner loop was an │ │ │ induction variable for the outer loop. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05230 │ Optimization Problem: Incorrect code was generated for an │ │ │ Optlink function containing a loop where an invariant was │ │ │ a register parameter and it was used in a conditional │ │ │ expression within the loop. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05393 │ Optimization Problem: The compiler was trapping when │ │ │ compiling code with consecutive calls to strcat with the │ │ │ same first parameter. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05431 │ Optimization Problem: The compiler was incorrectly │ │ │ removing a store to a local variable before a loop. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05450 │ The thunk prolog routine was using 64K too much stack in │ │ │ certain situations. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00014 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ05225 │ The original fix for this problem may have caused other │ │ │ optimization problems. Now we believe that we have a │ │ │ complete fix for this problem. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05303 │ Optimization Problem: A parameter in an _Optlink function │ │ │ that was assigned to a global register was not being kept │ │ │ alive long enough. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05737 │ A "data record too large" message from the linker was │ │ │ being generated when a union where the first member was │ │ │ more than 1024 bytes smaller than another member was │ │ │ being initialized OR when an aggregate within a user data │ │ │ segment was uninitialized. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05722 │ The compiler was generating an IMUL instruction with an │ │ │ operand size prefix but the constant was 32 bits long │ │ │ instead of 16-bits long. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05723 │ Optimization Problem: The compiler was trapping when │ │ │ trying to optimize a floating-point intensive procedure │ │ │ where floating-point spills and reloads were necessary. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05716 │ The compiler was emitting stack probes when the size of │ │ │ all local variables was greater than 4K instead of when │ │ │ the size is greater than 2K. In some cases, stack probes │ │ │ were being emitted in the wrong place as well. This │ │ │ would cause strange traps to occur in multi-threaded │ │ │ programs. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05728 │ Stack probes were not enabled during compilation of │ │ │ multi-threaded runtime library code. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05556 │ The runtime library termination routine was not checking │ │ │ to make sure runtime initialization had completed. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Provides a means to set the number of spaces to be │ │ │ inserted when tabs are encountered in the source file. │ │ │ The default tab expansion is 8 spaces, as it was in the │ │ │ orignal IPMD. A new environment variable, PMDTAB, is now │ │ │ available to customize the tab expansion constant. For │ │ │ example, "SET PMDTAB=5" causes 5 spaces to be inserted │ │ │ for every tab. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05863 │ In multithreaded applications, the debugger would perform │ │ │ a "Run" when a "Step over" or a "Step debug" was │ │ │ requested. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05148 │ Internal debugger errors were sometimes reported when │ │ │ performing a "Find" and when scrolling the source view. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05117 │ Occasionally the debugger would automatically shut itself │ │ │ down when creating or scrolling a source view. Included │ │ │ in this APAR is a problem in which the application is left│ │ │ active when the debugger terminates after an exception. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ General internal PM debugging enhancements. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ General internal storage window enhancements. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ The name displayed for a subscripted array (i.e., x(i)) │ │ │ is not always updated - if the value remains the same │ │ │ while the name changes, the name is not updated. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ If the stack window is open and data is entered in the │ │ │ application window, the stack view can display the wrong │ │ │ part name for a function name. This can also cause the │ │ │ debugger to crash if the focus is changed between the │ │ │ source, the stack, and the application several times. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00022 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ NOAPAR │ Exception handler registration records were causing stack │ │ │ chaining to be disabled because of their location in the │ │ │ instruction stream. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06109 │ Optimization Problem: Multiplication by some particular │ │ │ constants was being done incorrectly when the /G4 switch │ │ │ was specified. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06417 │ The compiler was not generating code to check for NULL │ │ │ before calling _DosSelToFlat when a 16-bit pointer was │ │ │ being converted to a 32-bit pointer. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06023 │ Optimization Problem: The wrong register was being used │ │ │ when a virtual global register was reassociated with a │ │ │ different real register. This showed up with nested loops │ │ │ where an induction variable in an outer loop is an │ │ │ invariant within an inner loop. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Optimization Problem: Multiplication by certain negative │ │ │ constants was being done incorrectly. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06022 │ Optimization Problem: A parameter register was not being │ │ │ kept alive until the end of a loop when the last use of │ │ │ the parameter is within the loop. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ05928 │ Floating Point Number Formatting Problem: Printf │ │ │ formating with %g was crashing if the precision │ │ │ requested exceeded 16 digits. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06439 │ Ceil and Floor Functions did not restore 387 flags. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06454 │ Exception Handler Problem: If an exception occurs during │ │ │ a library critical routine, and a second user exception │ │ │ occurs while in a nested critical routine belonging to │ │ │ the first exception, the exception handler will loop and │ │ │ hang the process. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06436 │ Optimization Problem: Statements of the form: │ │ │ "if (bool) {x.a = const} else {x.b = const}" were being │ │ │ simplified incorrectly to "x.a=const". │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00026 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ NOAPAR │ DBCS enablement changes to IPMD. │ │ │ Add the keyboard status indicator to the dialogs. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ DBCS enabled. Fixed the stack probe option. │ │ │ Updated help text for the stack probe option and added │ │ │ the key help for the DDE4CSET.DLL. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06460 │ Optimization Problem: If an extern is modified inside a │ │ │ loop while it's in a register, jumping from within that │ │ │ loop to a return could sometimes bypass the code that │ │ │ copies the register back to memory. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06459 │ Optimization Problem: Consecutive calls to the memmove, │ │ │ memcpy, or memset functions with similar destination │ │ │ addresses could fail if the returned address from the │ │ │ first call is used before the second call. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06584 │ Occasionally with optimization, loop exits coinciding with│ │ │ function exits caused incorrect termination of the loop. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06610 │ Optimization Problem: Statements of the form: │ │ │ "if (bool) {x = const0} else {x = const1}" could cause │ │ │ a compile-time exception if "x" is an address. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06593 │ Optimization Problem: Statements of the form given above │ │ │ (PJ06610) could be incorrectly optimized if the "bool" │ │ │ expression does not contain a relational or equality │ │ │ operator. For example: (bool) or (!bool). │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06637 │ Passing structs by value during _Optlink calls could cause│ │ │ the caller to incorrectly set up subsequent parameters. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06742 │ The compiler could incorrectly set up the return register │ │ │ for calls to _DosFlatToSel with 16-bit function pointers, │ │ │ and thus cause register selection problems. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06583 │ Optimization Problem: Gotos within the inner loop of a │ │ │ nested loop could cause incorrect spilling of a variable │ │ │ if the variable was used in the inner loop but not in │ │ │ the outer loops. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06813 │ Optimization Problem: A floating-point cast of the same │ │ │ integer variable both before and inside an "if" could │ │ │ cause the floating-point stack to become inconsistant. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06623 │ Freopen Library Function: freopen function did not allow │ │ │ the changing of the text/binary mode of a standard stream │ │ │ without redirecting to a different file. For example: │ │ │ freopen( "", "rb", stdin ); │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06904 │ Relax some of the restrictions on arrays of incomplete │ │ │ types so that cfront-generated code can compile. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06776 │ When a comma operator is used to evaluate the address │ │ │ of a function being called, an internal compiler error │ │ │ occurs. Code Generation of Front End now fixed. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00028 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ06624 │ Optimization Problem: Using the address of a parameter │ │ │ passed in a register could cause the compiler to trap │ │ │ if basic blocks are merged. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06768 │ Optimization Problem: Multiplying two addresses that have │ │ │ been cast to integers could cause the compiler to trap. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06846 │ Optimization Problem: A large number of consecutive │ │ │ statements that each use values calculated in previous │ │ │ statements could cause the swapper to grow very large. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06841 │ Optimization Problem: The compiler could trap if the last │ │ │ "if" in a loop turns into a jump to the top of the loop. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00030 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ06929 │ Optimization Problem: A ternary within a loop could in │ │ │ very rare cases cause a global register to be incorrectly │ │ │ clobbered. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06881 │ Folding of the following expressions incorrectly removed │ │ │ x if x had side effects: (0 / x) ---> 0 │ │ │ (0 % x) ---> 0 │ │ │ (x % 1) ---> 0 │ │ │ (x % -1) ---> 0 │ │ │ (x * 0) ---> 0 │ │ │ (x & 0) ---> 0 │ │ │ (x | -1) ---> -1 │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06862 │ Optimization Problem: This is a more general fix to the │ │ │ problem dealt with in PJ06846. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06908 │ Without optimization, casts from an unsigned short to a │ │ │ double could yield incorrect conversions. The problem │ │ │ disappears when compiling with /O+. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Allow ASCII characters above 0x80 to display in the │ │ │ source view of the debugger │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00032 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ07151 │ Optimization Problem: Transformation of a simple loop to │ │ │ either a memset or a memcpy could create initialization │ │ │ problems if the loop induction variable is unsigned. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07244 │ Optimization Problem: The constant value stored during │ │ │ the builtin memset could be incorrectly calculated for │ │ │ char and short types. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06920 │ Preprocessor Problem: If a macro replacement token is │ │ │ empty, in some cases we were erroneously substituting │ │ │ it with a right parenthesis. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07198 │ Optimization Problem: Dead store removal within loops │ │ │ failed to consider conditional stores and thus could │ │ │ incorrectly remove a store that was not dead. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ06024 │ Optimization Problem: Bad invariant code motion could │ │ │ result in a general protection fault at compile-time. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07215 │ Optimization Problem: Calls to 16-bit functions could │ │ │ cause inappropriate tail-call optimization to occur. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07253 │ An internal problem could cause a compile-time general │ │ │ protection fault when generating debugger information │ │ │ without optimization. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07259 │ FE Problem: When utilizing a pointer to a pointer to data,│ │ │ the compiler is only dereferencing the pointer once. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Optimization Problem: An internal problem could cause │ │ │ a compile-time general protection fault when keeping a │ │ │ floating-point parameter alive in a register. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00034 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ NOAPAR │ Optimization Problem: Strength reduction of a │ │ │ compiler-generated constant could result in a general │ │ │ protection fault at compile-time. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Optimization Problem: Tail recursion elimination could │ │ │ incorrectly handle parameter aliases. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ BE Problem: Incorrect code may be generated for _Far16 │ │ │ _Pascal callback functions that return floating-point │ │ │ types. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07295 │ Performance improvement of strstr. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07356 │ _fullpath was not returning the correct result when │ │ │ ..\ was passed in as the partial path. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ BE Problem: Incorrect code may be generated with the │ │ │ combination of _alloca and #pragma handler. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00036 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ07414 │ Initialization Problem: Floating point 387 not cleared │ │ │ during runtime initialization. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07631 │ Calloc Problem: Storage returned from calloc was not │ │ │ set to zeroes after a realloc to a smaller size. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Dump Problem: Incorrect NPX values were being displayed │ │ │ for floating point exception dumps. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Fastsem: Making Fastsem multiprocessor safe. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07672 │ I/O problem: When a nonseekable device (e.g. LPT1, CON, │ │ │ pipe, COM1) is opened with append mode, any attempt to │ │ │ write to such device will fail with an OS/2 error 132. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07673 │ FE Problem: Pointer to structure member (that is a struct)│ │ │ assigned to pointer to structure member (also a struct) │ │ │ and then applying dot operator caused incorrect code. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07600 │ DDE4.NDX - Removed incorrect references to the │ │ │ toolkit information. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00038 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ07710 │ Optimization Problem: Casting char or short types to a │ │ │ long type and then performing a bitwise AND on the result │ │ │ could lead to incorrect code generation if the upper 16 │ │ │ bits of the AND mask contain set bits. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Optimization Problem: A do loop with a complex while │ │ │ condition could be incorrectly unrolled. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Optimization Problem: An internal problem could cause │ │ │ a compile-time general protection fault when destroying │ │ │ unreachable code. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07429 │ Optimization Problem: If the last use of a floating-point │ │ │ parameter occurs near the beginning of a function before │ │ │ any control flow statements, that parameter could be left │ │ │ on the floating-point stack when the function returns. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07422 │ FE Problem: Compiler is erroneously generating warning │ │ │ message EDC0830 on some enum usage when compiled with │ │ │ -Ke+ switch. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07766 │ Compiler Trap: The compiler would generate an exception │ │ │ if a bitfield was post-incremented and used as the right │ │ │ hand side of an assignment within the same statement. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00040 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ07908 │ Library Problem: Exception occurs when user presses │ │ │ control c in a conio input routine. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07909 │ Library Problem: Memory allocation performance improvement│ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07984 │ Optimization Problem: Constant propagation could be │ │ │ performed incorrectly when a store to one member of a │ │ │ union clobbers a store to another member. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ07986 │ Optimization Problem: If the last usage of a register │ │ │ parameter is a store in the last block of a loop, then │ │ │ incorrect code could be generated. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08032 │ Optimization Problem: Post-incrementing a variable that │ │ │ is used as a parameter to consecutive function calls could│ │ │ cause incorrect constant propagation. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08046 │ Library Problem: Change macro definition of isascii. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08065 │ BE Problem: Pointer subtraction, where the pointers point │ │ │ to members of a structure, could cause incorrect code │ │ │ generation. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08066 │ Optimization Problem: A ternary that uses volatile unions │ │ │ could cause incorrect code generation if the result of the│ │ │ conditional expression is used immediately after. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00042 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ NOAPAR │ Compiler Trap: An internal problem could cause │ │ │ a general protection fault during compilation. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Library Problem: Fixed obscure malloc/heapmin bug. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00044 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ NOAPAR │ Optimization Problem: An internal problem with loop │ │ │ invariant code motion could cause a compile-time error. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08413 │ BE Problem: Under certain conditions, memset was not │ │ │ clearing the upper 2 bytes of the value register. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08285 │ BE Problem: Incorrect code generated when right shifting │ │ │ an unsigned char, which has been casted to a long, and │ │ │ then assigning the result to an unsigned char. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08300 │ RT Problem: _fullpath cannot parse "G:" , "C:", etc. │ │ │ This is an API behaviour. Since C386 can parse the │ │ │ above correctly, we decided to modify the call to │ │ │ the API to accept "C:", "G:", etc. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08415 │ Optimization Problem: Global folding could be performed │ │ │ incorrectly when a store to one member of a union clobbers│ │ │ a store to another member. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08286 │ Optimization Problem: Gotos near the bottom of a loop │ │ │ which jump to code right after the loop could cause │ │ │ incorrect code to be generated. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08456 │ BE Problem: Returning a struct by value could result in │ │ │ incorrect code generation if the return statement calls │ │ │ another function whose return type is a pointer to struct.│ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ Optimization Problem: Tail call optimization could │ │ │ generate incorrect code if the current function contains │ │ │ a call to _alloca. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08473 │ FE Problem: Casts from function pointers to segmented │ │ │ data pointers were improperly being flagged as errors. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00046 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ08488 │ Optimization Problem: A parameter register could be │ │ │ incorrectly clobbered if a use follows a def. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08489 │ Optimization Problem: The register assigner could │ │ │ choose the wrong register when trying to optimize the │ │ │ use of byte registers. (ie: AL vs AH) │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08487 │ Optimization Problem: A problem in the builtin memmove │ │ │ could cause a run-time general protection fault. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08486 │ BE Problem: Assigning a function returning an aggregate │ │ │ to an array element whose index results from evaluating │ │ │ another function could cause incorrect code generation. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00048 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ PJ08712 │ BE Problem: Casting 0xFFFF0001 to unsigned long and then │ │ │ to unsigned short incorrectly gives 0 instead of 1. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ09159 │ FE Problem: pointers in 16-bit function definitions │ │ │ were not getting _Seg16 qualifiers. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08715 │ Optimization Problem: An internal problem with strength │ │ │ reduction could cause a compile-time error. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08714 │ BE Problem: An internal problem with code generation │ │ │ could cause a compile-time general protection fault when │ │ │ generating debugger information. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ BE Problem: Copying large parameters (> 4096 bytes) onto │ │ │ the stack could be done incorrectly. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ BE Problem: An internal problem occuring while generating │ │ │ an assembler listing file could cause a compile-time │ │ │ general protection fault. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ08753 │ RT Problem: When flushing a buffer of size greater than │ │ │ 8192 (8K) bytes and the buffer contains no LF, the library│ │ │ will trap with a General Protection fault. This usually │ │ │ happens when the user sets the buffer size using setvbuf │ │ │ to a value greater than 8192. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ RT Problem: Function _getdcwd incorrectly returns NULL │ │ │ and sets errno to 60 when the pointer passed to _getdcwd │ │ │ function as the second parameter is NULL. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ NOAPAR │ FE Problem: Front-end might fail unpredictably when │ │ │ /Fl or /L option is specified without source listing (/Ls)│ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00050 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ QUAL-IMP │ BE Problem: Incorrect code may be generated when copying │ │ │ structures whose size is less than 12 bytes. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ11434 │ Optimization Problem: Bad register selection around switch│ │ │ statements could cause incorrect code generation. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ11435 │ Optimization Problem: An internal problem occuring during │ │ │ global folding could cause a run-time exception. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ11436 │ Optimization Problem: When an infinite loop has a │ │ │ conditional return as its last statement, incorrect code │ │ │ may be generated if a variable used in the return was │ │ │ assigned to a register within the loop. │ ├───────────────┼────────────────────────────────────────────────────────────┤ │ PJ11437 │ BE Problem: Without optimization, an expression of the │ │ │ form "*((char*)&array[index]+i)" could generate an │ │ │ incorrect OBJ even though the ASM is correct. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00054 │ │ │ ╞═══════════════╤════════════════════════════════════════════════════════════╡ │ NOAPAR │ Optimization Problem: Incorrect register selection could │ │ │ lead to traps or unexpected results with 32 to 16 or │ │ │ 16 to 32 code. │ ╞═══════════════╧════════════════════════════════════════════════════════════╡ │ │ │ All the fixes listed above were included in CS00056 │ │ │ ╘════════════════════════════════════════════════════════════════════════════╛